home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / ab20 / unarced / utilities / emulators / apple][ / a2.c < prev    next >
C/C++ Source or Header  |  1995-03-17  |  24KB  |  1,684 lines
  1. /*
  2.  *  a2, an Apple II emulator in C
  3.  *  (c) Copyright 1990 by Rich Skrenta
  4.  *
  5.  *  Command line interface written by Tom Markson
  6.  *
  7.  *  Distribution agreement:
  8.  *
  9.  *    You may freely copy or redistribute this software, so long
  10.  *    as there is no profit made from its use, sale, trade or
  11.  *    reproduction.  You may not change this copyright notice,
  12.  *    and it must be included prominently in any copy made.
  13.  *
  14.  *  Send emulator related mail to:  skrenta@blekko.commodore.com
  15.  *                    skrenta@blekko.uucp
  16.  */
  17.  
  18.  
  19. #include    <stdio.h>
  20. #include    "a2.h"
  21.  
  22. #define    BRANCH()    val = mem[Pc++]; if (val & 0x80) Pc += val - 256; else Pc += val;
  23.  
  24. #define    put_status(s) stmp = s; N = stmp & 0x80; V = stmp & 0x40; B = stmp & 0x10; D = stmp & 0x08; I = stmp & 0x04; NZ = !(stmp & 0x02); C = stmp & 0x01;
  25.  
  26.  
  27. extern long trace_lo, trace_hi;
  28. extern FILE *logging_fp;
  29. extern long phantom_location;
  30. extern long breakpoint;
  31.  
  32.  
  33.  
  34. run()
  35. {
  36. register unsigned short ptr;
  37. register unsigned short ptmp;
  38. register unsigned int val;
  39. register unsigned int tmp;
  40. register unsigned int num;
  41. unsigned char stmp;
  42. int foo;
  43. int show_flags = FALSE;
  44.  
  45.  
  46.     do {                    /* while (tracing) */
  47.     if (tracing) {
  48.  
  49.         if (breakpoint == Pc) {
  50.             MoveCursor(term_lines, 0);
  51.             printf("Break at $%.4X\n", Pc);
  52.             return;
  53.         }
  54.  
  55.         if (phantom_location == (long) Pc)
  56.             phantom_location = -1;        /* start tracing now */
  57.  
  58.         if (phantom_location == -1
  59.         &&  trace_lo != -1
  60.         &&  (long) Pc >= trace_lo
  61.         &&  (long) Pc <= trace_hi) {
  62.             diss(Pc, logging_fp);
  63.             show_flags = TRUE;
  64.         } else
  65.             show_flags = FALSE;
  66.     }
  67.  
  68.  
  69.     do {                    /* while (running) */
  70.         switch (mem[Pc++]) {
  71.         case 0x00:            /* BRK */
  72.             PCINC;
  73.             push(high(Pc));
  74.             push(low(Pc));
  75.             B = 1;                /* set I flag? */
  76.             push(get_status());
  77.             Pc = join(mem[0xFFFE], mem[0xFFFF]);
  78.             break;
  79.  
  80.         case 0x01:    /* ORA (indirect, X) */
  81.             INDX;
  82.             A |= REFptr;
  83.             SIGN(A);
  84.             ZERO(A);
  85.             break;
  86.  
  87.         case 0x02:
  88.             break;
  89.  
  90.         case 0x03:
  91.             break;
  92.  
  93.         case 0x04:    /* TSB zero page    65C02 */
  94.             break;
  95.  
  96.         case 0x05:    /* ORA zero page */
  97.             A |= rZEROP;
  98.             SIGN(A);
  99.             ZERO(A);
  100.             break;
  101.  
  102.         case 0x06:    /* ASL zero page */
  103.             ZEROP;
  104.             val = REFzero << 1;
  105.             CARRY(val);
  106.             val &= 0xFF;
  107.             SETzero(val);
  108.             SIGN(val);
  109.             ZERO(val);
  110.             break;
  111.  
  112.         case 0x07:
  113.             break;
  114.  
  115.         case 0x08:    /* PHP */
  116.             push(get_status());
  117.             break;
  118.  
  119.         case 0x09:    /* ORA immediate */
  120.             A |= REFimm;
  121.             SIGN(A);
  122.             ZERO(A);
  123.             break;
  124.  
  125.         case 0x0A:    /* ASL accumulator */
  126.             A = A << 1;
  127.             CARRY(A);
  128.             A &= 0xFF;
  129.             SIGN(A);
  130.             ZERO(A);
  131.             break;
  132.  
  133.         case 0x0B:
  134.             break;
  135.  
  136.         case 0x0C:    /* TSB absolute        65C02 */
  137.             break;
  138.  
  139.         case 0x0D:    /* ORA absolute */
  140.             ABSOL;
  141.             A |= REFptr;
  142.             SIGN(A);
  143.             ZERO(A);
  144.             break;
  145.  
  146.         case 0x0E:    /* ASL absolute */
  147.             ABSOL;
  148.             val = REFptr << 1;
  149.             CARRY(val);
  150.             val &= 0xFF;
  151.             SETptr(val);
  152.             SIGN(val);
  153.             ZERO(val);
  154.             break;
  155.  
  156.         case 0x0F:
  157.             break;
  158.  
  159.         case 0x10:    /* BPL */
  160.             if (N) {
  161.                 PCINC;
  162.             } else {
  163.                 BRANCH();
  164.             }
  165.             break;
  166.  
  167.         case 0x11:    /* ORA (indirect), Y */
  168.             INDY;
  169.             A |= REFptr;
  170.             SIGN(A);
  171.             ZERO(A);
  172.             break;
  173.  
  174.         case 0x12:    /* ORA (indz)        65C02 */
  175.             break;
  176.  
  177.         case 0x13:
  178.             break;
  179.  
  180.         case 0x14:    /* TRB zero page    65C02 */
  181.             break;
  182.  
  183.         case 0x15:    /* ORA zero page, X */
  184.             A |= rZEROX;
  185.             SIGN(A);
  186.             ZERO(A);
  187.             break;
  188.  
  189.         case 0x16:    /* ASL zero page, X */
  190.             ZEROX;
  191.             val = REFzero << 1;
  192.             CARRY(val);
  193.             val &= 0xFF;
  194.             SETzero(val);
  195.             SIGN(val);
  196.             ZERO(val);
  197.             break;
  198.  
  199.         case 0x17:
  200.             break;
  201.  
  202.         case 0x18:    /* CLC */
  203.             C = 0;
  204.             break;
  205.  
  206.         case 0x19:    /* ORA absolute, Y */
  207.             ABSY;
  208.             A |= REFptr;
  209.             SIGN(A);
  210.             ZERO(A);
  211.             break;
  212.  
  213.         case 0x1A:    /* INA            65C02 */
  214.             break;
  215.  
  216.         case 0x1C:    /* TRB absolute        65C02 */
  217.             break;
  218.  
  219.         case 0x1D:    /* ORA absolute, X */
  220.             ABSX;
  221.             A |= REFptr;
  222.             SIGN(A);
  223.             ZERO(A);
  224.             break;
  225.  
  226.         case 0x1E:    /* ASL absolute, X */
  227.             ABSX;
  228.             val = REFptr << 1;
  229.             CARRY(val);
  230.             val &= 0xFF;
  231.             SETptr(val);
  232.             SIGN(val);
  233.             ZERO(val);
  234.             break;
  235.  
  236.         case 0x1F:
  237.             break;
  238.  
  239.         case 0x20:    /* JSR */
  240.             ptmp = REFimm;
  241.             ptmp |= mem[Pc] << 8;
  242.             push(high(Pc));
  243.             push(low(Pc));
  244.             Pc = ptmp;
  245.  
  246.             if (jmp_tbl[Pc])
  247.                 jump(jmp_tbl[Pc]);
  248.             break;
  249.  
  250.         case 0x21:    /* AND (indirect, X) */
  251.             INDX;
  252.             A &= REFptr;
  253.             SIGN(A);
  254.             ZERO(A);
  255.             break;
  256.  
  257.         case 0x22:
  258.             break;
  259.  
  260.         case 0x23:
  261.             break;
  262.  
  263.         case 0x24:    /* BIT zero page */
  264.             tmp = rZEROP;
  265.             ZERO(A & tmp);
  266.             N = tmp & 0x80;
  267.             V = tmp & 0x40;
  268.             break;
  269.  
  270.         case 0x25:    /* AND zero page */
  271.             A &= rZEROP;
  272.             SIGN(A);
  273.             ZERO(A);
  274.             break;
  275.  
  276.         case 0x26:    /* ROL zero page */
  277.             ZEROP;
  278.             val = REFzero;
  279.             tmp = C;
  280.             val = val << 1;
  281.             CARRY(val);
  282.             val = (val & 0xFF) | tmp;
  283.             SETzero(val);
  284.             SIGN(val);
  285.             ZERO(val);
  286.             break;
  287.  
  288.         case 0x27:
  289.             break;
  290.  
  291.         case 0x28:    /* PLP */
  292.             put_status(pop());
  293.             break;
  294.  
  295.         case 0x29:    /* AND immediate */
  296.             A &= REFimm;
  297.             SIGN(A);
  298.             ZERO(A);
  299.             break;
  300.  
  301.         case 0x2A:    /* ROL accumulator */
  302.             tmp = C;
  303.             A = A << 1;
  304.             CARRY(A);
  305.             A = (A & 0xFF) | tmp;
  306.             SIGN(A);
  307.             ZERO(A);
  308.             break;
  309.  
  310.         case 0x2B:
  311.             break;
  312.  
  313.         case 0x2C:    /* BIT absolute */
  314.             ABSOL;
  315.             tmp = REFptr;
  316.             ZERO(A & tmp);
  317.             N = tmp & 0x80;
  318.             V = tmp & 0x40;
  319.             break;
  320.  
  321.         case 0x2D:    /* AND absolute */
  322.             ABSOL;
  323.             A &= REFptr;
  324.             SIGN(A);
  325.             ZERO(A);
  326.             break;
  327.  
  328.         case 0x2E:    /* ROL absolute */
  329.             ABSOL;
  330.             val = REFptr;
  331.             tmp = C;
  332.             val = val << 1;
  333.             CARRY(val);
  334.             val = (val & 0xFF) | tmp;
  335.             SETptr(val);
  336.             SIGN(val);
  337.             ZERO(val);
  338.             break;
  339.  
  340.         case 0x2F:
  341.             break;
  342.  
  343.         case 0x30:    /* BMI */
  344.             if (N) {
  345.                 BRANCH();
  346.             } else{
  347.                 PCINC;
  348.             }
  349.             break;
  350.  
  351.         case 0x31:    /* AND (indirect), Y */
  352.             INDY;
  353.             A &= REFptr;
  354.             SIGN(A);
  355.             ZERO(A);
  356.             break;
  357.  
  358.         case 0x32:    /* AND (indz)        65C02 */
  359.             break;
  360.  
  361.         case 0x33:
  362.             break;
  363.  
  364.         case 0x34:    /* BIT zero page, X    65C02 */
  365.             break;
  366.  
  367.         case 0x35:    /* AND zero page, X */
  368.             A &= rZEROX;
  369.             SIGN(A);
  370.             ZERO(A);
  371.             break;
  372.  
  373.         case 0x36:    /* ROL zero page, X */
  374.             ZEROX;
  375.             val = REFzero;
  376.             tmp = C;
  377.             val = val << 1;
  378.             CARRY(val);
  379.             val = (val & 0xFF) | tmp;
  380.             SETzero(val);
  381.             SIGN(val);
  382.             ZERO(val);
  383.             break;
  384.  
  385.         case 0x37:
  386.             break;
  387.  
  388.         case 0x38:    /* SEC */
  389.             C = 1;
  390.             break;
  391.  
  392.         case 0x39:    /* AND absolute, Y */
  393.             ABSY;
  394.             A &= REFptr;
  395.             SIGN(A);
  396.             ZERO(A);
  397.             break;
  398.  
  399.         case 0x3A:    /* DEA            65C02 */
  400.             break;
  401.  
  402.         case 0x3B:
  403.             break;
  404.  
  405.         case 0x3C:    /* BIT absolute, X    65C02 */
  406.             break;
  407.  
  408.         case 0x3D:    /* AND absolute, X */
  409.             ABSX;
  410.             A &= REFptr;
  411.             SIGN(A);
  412.             ZERO(A);
  413.             break;
  414.  
  415.         case 0x3E:    /* ROL absolute, X */
  416.             ABSX;
  417.             val = REFptr;
  418.             tmp = C;
  419.             val = val << 1;
  420.             CARRY(val);
  421.             val = (val & 0xFF) | tmp;
  422.             SETptr(val);
  423.             SIGN(val);
  424.             ZERO(val);
  425.             break;
  426.  
  427.         case 0x3F:
  428.             break;
  429.  
  430.         case 0x40:    /* RTI */
  431.             put_status(pop());
  432.             Pc = pop();
  433.             Pc |= pop() << 8;
  434.             break;
  435.  
  436.         case 0x41:    /* EOR (indirect, X) */
  437.             INDX;
  438.             A ^= REFptr;
  439.             SIGN(A);
  440.             ZERO(A);
  441.             break;
  442.  
  443.         case 0x42:
  444.             break;
  445.  
  446.         case 0x43:
  447.             break;
  448.  
  449.         case 0x44:
  450.             break;
  451.  
  452.         case 0x45:    /* EOR zero page */
  453.             A ^= rZEROP;
  454.             SIGN(A);
  455.             ZERO(A);
  456.             break;
  457.  
  458.         case 0x46:    /* LSR zero page */
  459.             ZEROP;
  460.             tmp = REFzero;
  461.             C = (tmp & 0x01);
  462.             tmp = tmp >> 1;
  463.             SETzero(tmp);
  464.             N = 0;
  465.             ZERO(tmp);
  466.             break;
  467.  
  468.         case 0x47:
  469.             break;
  470.  
  471.         case 0x48:    /* PHA */
  472.             push(A);
  473.             break;
  474.  
  475.         case 0x49:    /* EOR immediate */
  476.             A ^= REFimm;
  477.             SIGN(A);
  478.             ZERO(A);
  479.             break;
  480.  
  481.         case 0x4A:    /* LSR accumulator */
  482.             C = (A & 0x01);
  483.             A = A >> 1;
  484.             N = 0;
  485.             ZERO(A);
  486.             break;
  487.  
  488.         case 0x4B:
  489.             break;
  490.  
  491.         case 0x4C:    /* JMP absolute */
  492.             ptmp = REFimm;
  493.             ptmp |= REFimm << 8;
  494.             Pc = ptmp;
  495.  
  496.             if (jmp_tbl[Pc])
  497.                 jump(jmp_tbl[Pc]);
  498.             break;
  499.  
  500.         case 0x4D:    /* EOR absolute */
  501.             ABSOL;
  502.             A ^= REFptr;
  503.             SIGN(A);
  504.             ZERO(A);
  505.             break;
  506.  
  507.         case 0x4E:    /* LSR absolute */
  508.             ABSOL;
  509.             tmp = REFptr;
  510.             C = (tmp & 0x01);
  511.             tmp = tmp >> 1;
  512.             SETptr(tmp);
  513.             N = 0;
  514.             ZERO(tmp);
  515.             break;
  516.  
  517.         case 0x4F:
  518.             break;
  519.  
  520.         case 0x50:    /* BVC */
  521.             if (V) {
  522.                 PCINC;
  523.             } else {
  524.                 BRANCH();
  525.             }
  526.             break;
  527.  
  528.         case 0x51:    /* EOR (indirect), Y */
  529.             INDY;
  530.             A ^= REFptr;
  531.             SIGN(A);
  532.             ZERO(A);
  533.             break;
  534.  
  535.         case 0x52:    /* EOR (indz)        65C02 */
  536.             break;
  537.  
  538.         case 0x53:
  539.             break;
  540.  
  541.         case 0x54:
  542.             break;
  543.  
  544.         case 0x55:    /* EOR zero page, X */
  545.             A ^= rZEROX;
  546.             SIGN(A);
  547.             ZERO(A);
  548.             break;
  549.  
  550.         case 0x56:    /* LSR zero page, X */
  551.             ZEROX;
  552.             tmp = REFzero;
  553.             C = (tmp & 0x01);
  554.             tmp = tmp >> 1;
  555.             SETzero(tmp);
  556.             N = 0;
  557.             ZERO(tmp);
  558.             break;
  559.  
  560.         case 0x57:
  561.             break;
  562.  
  563.         case 0x58:    /* CLI */
  564.             I = 0;
  565.             break;
  566.  
  567.         case 0x59:    /* EOR absolute, Y */
  568.             ABSY;
  569.             A ^= REFptr;
  570.             SIGN(A);
  571.             ZERO(A);
  572.             break;
  573.  
  574.         case 0x5A:    /* PHY        65C02 */
  575.             break;
  576.  
  577.         case 0x5B:
  578.             break;
  579.  
  580.         case 0x5C:
  581.             break;
  582.  
  583.         case 0x5D:    /* EOR absolute, X */
  584.             ABSX;
  585.             A ^= REFptr;
  586.             SIGN(A);
  587.             ZERO(A);
  588.             break;
  589.  
  590.         case 0x5E:    /* LSR absolute, X */
  591.             ABSX;
  592.             tmp = REFptr;
  593.             C = (tmp & 0x01);
  594.             tmp = tmp >> 1;
  595.             SETptr(tmp);
  596.             N = 0;
  597.             ZERO(tmp);
  598.             break;
  599.  
  600.         case 0x5F:
  601.             break;
  602.  
  603.         case 0x60:    /* RTS */
  604.             DO_RTS;
  605.             break;
  606.  
  607.         case 0x61:    /* ADC (indirect, X) */
  608.             INDX;
  609.             val = REFptr;
  610.             tmp = A & 0x80;
  611.             stmp = val & 0x80;
  612.             if (D) {
  613.                 num = tobinary(val);
  614.                 val = tobinary(A);
  615.  
  616.                 val += num + C;
  617.                 dCARRY(val);
  618.                 while (val >= 100)
  619.                     val -= 100;
  620.  
  621.                 A = tobcd(val);
  622.             } else {
  623.                 A += val + C;
  624.                 CARRY(A);
  625.                 A &= 0xFF;
  626.             }
  627.             ZERO(A);
  628.             SIGN(A);
  629.             V = (tmp == stmp) && (tmp != N);
  630.             break;
  631.  
  632.         case 0x62:
  633.             break;
  634.  
  635.         case 0x63:
  636.             break;
  637.  
  638.         case 0x64:    /* STZ zero page    65C02 */
  639.             break;
  640.  
  641.         case 0x65:    /* ADC zero page */
  642.             val = rZEROP;
  643.             tmp = A & 0x80;
  644.             stmp = val & 0x80;
  645.             if (D) {
  646.                 num = tobinary(val);
  647.                 val = tobinary(A);
  648.  
  649.                 val += num + C;
  650.                 dCARRY(val);
  651.                 while (val >= 100)
  652.                     val -= 100;
  653.  
  654.                 A = tobcd(val);
  655.             } else {
  656.                 A += val + C;
  657.                 CARRY(A);
  658.                 A &= 0xFF;
  659.             }
  660.             ZERO(A);
  661.             SIGN(A);
  662.             V = (tmp == stmp) && (tmp != N);
  663.             break;
  664.  
  665.  
  666.         case 0x66:    /* ROR zero page */
  667.             ZEROP;
  668.             val = REFzero;
  669.             tmp = C;
  670.             C = val & 0x01;
  671.             val = val >> 1;
  672.             val |= tmp << 7;
  673.             SETzero(val);
  674.             SIGN(val);
  675.             ZERO(val);
  676.             break;
  677.  
  678.         case 0x67:
  679.             break;
  680.  
  681.         case 0x68:    /* PLA */
  682.             A = pop();
  683.             SIGN(A);
  684.             ZERO(A);
  685.             break;
  686.  
  687.         case 0x69:    /* ADC immediate */
  688.             val = REFimm;
  689.             tmp = A & 0x80;
  690.             stmp = val & 0x80;
  691.             if (D) {
  692.                 num = tobinary(val);
  693.                 val = tobinary(A);
  694.  
  695.                 val += num + C;
  696.                 dCARRY(val);
  697.                 while (val >= 100)
  698.                     val -= 100;
  699.  
  700.                 A = tobcd(val);
  701.             } else {
  702.                 A += val + C;
  703.                 CARRY(A);
  704.                 A &= 0xFF;
  705.             }
  706.             ZERO(A);
  707.             SIGN(A);
  708.             V = (tmp == stmp) && (tmp != N);
  709.             break;
  710.  
  711.         case 0x6A:    /* ROR accumulator */
  712.             tmp = C;
  713.             C = A & 0x01;
  714.             A = A >> 1;
  715.             A |= tmp << 7;
  716.             SIGN(A);
  717.             ZERO(A);
  718.             break;
  719.  
  720.         case 0x6B:
  721.             break;
  722.  
  723.         case 0x6C:    /* JMP indirect */
  724.             ptmp = REFimm;
  725.             ptmp |= REFimm << 8;
  726.             Pc = mem[ptmp++];
  727.             Pc |= mem[ptmp] << 8;
  728.  
  729.             if (jmp_tbl[Pc])
  730.                 jump(jmp_tbl[Pc]);
  731.             break;
  732.  
  733.         case 0x6D:    /* ADC absolute */
  734.             ABSOL;
  735.             val = REFptr;
  736.             tmp = A & 0x80;
  737.             stmp = val & 0x80;
  738.             if (D) {
  739.                 num = tobinary(val);
  740.                 val = tobinary(A);
  741.  
  742.                 val += num + C;
  743.                 dCARRY(val);
  744.                 while (val >= 100)
  745.                     val -= 100;
  746.  
  747.                 A = tobcd(val);
  748.             } else {
  749.                 A += val + C;
  750.                 CARRY(A);
  751.                 A &= 0xFF;
  752.             }
  753.             ZERO(A);
  754.             SIGN(A);
  755.             V = (tmp == stmp) && (tmp != N);
  756.             break;
  757.  
  758.         case 0x6E:    /* ROR absolute */
  759.             ABSOL;
  760.             val = REFptr;
  761.             tmp = C;
  762.             C = val & 0x01;
  763.             val = val >> 1;
  764.             val |= tmp << 7;
  765.             SETptr(val);
  766.             SIGN(val);
  767.             ZERO(val);
  768.             break;
  769.  
  770.         case 0x6F:
  771.             break;
  772.  
  773.         case 0x70:    /* BVS */
  774.             if (V) {
  775.                 BRANCH();
  776.             } else {
  777.                 PCINC;
  778.             }
  779.             break;
  780.  
  781.         case 0x71:    /* ADC (indirect),Y */
  782.             INDY;
  783.             val = REFptr;
  784.             tmp = A & 0x80;
  785.             stmp = val & 0x80;
  786.             if (D) {
  787.                 num = tobinary(val);
  788.                 val = tobinary(A);
  789.  
  790.                 val += num + C;
  791.                 dCARRY(val);
  792.                 while (val >= 100)
  793.                     val -= 100;
  794.  
  795.                 A = tobcd(val);
  796.             } else {
  797.                 A += val + C;
  798.                 CARRY(A);
  799.                 A &= 0xFF;
  800.             }
  801.             ZERO(A);
  802.             SIGN(A);
  803.             V = (tmp == stmp) && (tmp != N);
  804.             break;
  805.  
  806.         case 0x72:    /* ADC (indz)        65C02 */
  807.             break;
  808.  
  809.         case 0x73:
  810.             break;
  811.  
  812.         case 0x74:    /* STZ zero page, X    65C02 */
  813.             break;
  814.  
  815.         case 0x75:    /* ADC zero page, X */
  816.             val = rZEROX;
  817.             tmp = A & 0x80;
  818.             stmp = val & 0x80;
  819.             if (D) {
  820.                 num = tobinary(val);
  821.                 val = tobinary(A);
  822.  
  823.                 val += num + C;
  824.                 dCARRY(val);
  825.                 while (val >= 100)
  826.                     val -= 100;
  827.  
  828.                 A = tobcd(val);
  829.             } else {
  830.                 A += val + C;
  831.                 CARRY(A);
  832.                 A &= 0xFF;
  833.             }
  834.             ZERO(A);
  835.             SIGN(A);
  836.             V = (tmp == stmp) && (tmp != N);
  837.             break;
  838.  
  839.         case 0x76:    /* ROR zero page, X */
  840.             ZEROX;
  841.             val = REFzero;
  842.             tmp = C;
  843.             C = val & 0x01;
  844.             val = val >> 1;
  845.             val |= tmp << 7;
  846.             SETzero(val);
  847.             SIGN(val);
  848.             ZERO(val);
  849.             break;
  850.  
  851.         case 0x77:
  852.             break;
  853.  
  854.         case 0x78:    /* SEI */
  855.             I = 1;
  856.             break;
  857.  
  858.         case 0x79:    /* ADC absolute, Y */
  859.             ABSY;
  860.             val = REFptr;
  861.             tmp = A & 0x80;
  862.             stmp = val & 0x80;
  863.             if (D) {
  864.                 num = tobinary(val);
  865.                 val = tobinary(A);
  866.  
  867.                 val += num + C;
  868.                 dCARRY(val);
  869.                 while (val >= 100)
  870.                     val -= 100;
  871.  
  872.                 A = tobcd(val);
  873.             } else {
  874.                 A += val + C;
  875.                 CARRY(A);
  876.                 A &= 0xFF;
  877.             }
  878.             ZERO(A);
  879.             SIGN(A);
  880.             V = (tmp == stmp) && (tmp != N);
  881.             break;
  882.  
  883.         case 0x7A:    /* PLY        65C02 */
  884.             break;
  885.  
  886.         case 0x7B:
  887.             break;
  888.  
  889.         case 0x7C:    /* JMP (abs indirect, X)    65C02 */
  890.             break;
  891.  
  892.         case 0x7D:    /* ADC absolute, X */
  893.             ABSX;
  894.             val = REFptr;
  895.             tmp = A & 0x80;
  896.             stmp = val & 0x80;
  897.             if (D) {
  898.                 num = tobinary(val);
  899.                 val = tobinary(A);
  900.  
  901.                 val += num + C;
  902.                 dCARRY(val);
  903.                 while (val >= 100)
  904.                     val -= 100;
  905.  
  906.                 A = tobcd(val);
  907.             } else {
  908.                 A += val + C;
  909.                 CARRY(A);
  910.                 A &= 0xFF;
  911.             }
  912.             ZERO(A);
  913.             SIGN(A);
  914.             V = (tmp == stmp) && (tmp != N);
  915.             break;
  916.  
  917.         case 0x7E:    /* ROR absolute, X */
  918.             ABSX;
  919.             val = REFptr;
  920.             tmp = C;
  921.             C = val & 0x01;
  922.             val = val >> 1;
  923.             val |= tmp << 7;
  924.             SETptr(val);
  925.             SIGN(val);
  926.             ZERO(val);
  927.             break;
  928.  
  929.         case 0x7F:
  930.             break;
  931.  
  932.         case 0x80:    /* BRA            65C02 */
  933.             break;
  934.  
  935.         case 0x81:    /* STA (indirect, X) */
  936.             INDX;
  937.             SETptr(A);
  938.             break;
  939.  
  940.         case 0x82:
  941.             break;
  942.  
  943.         case 0x83:
  944.             break;
  945.  
  946.         case 0x84:    /* STY zero page */
  947.             sZEROP(Y);
  948.             break;
  949.  
  950.         case 0x85:    /* STA zero page */
  951.             sZEROP(A);
  952.             break;
  953.  
  954.         case 0x86:    /* STX zero page */
  955.             sZEROP(X);
  956.             break;
  957.  
  958.         case 0x87:
  959.             break;
  960.  
  961.         case 0x88:    /* DEY */
  962.             Y--;
  963.             SIGN(Y);
  964.             ZERO(Y);
  965.             break;
  966.  
  967.         case 0x89:
  968.             break;
  969.  
  970.         case 0x8A:    /* TXA */
  971.             A = X;
  972.             SIGN(A);
  973.             ZERO(A);
  974.             break;
  975.  
  976.         case 0x8B:
  977.             break;
  978.  
  979.         case 0x8C:    /* STY absolute */
  980.             ABSOL;
  981.             SETptr(Y);
  982.             break;
  983.  
  984.         case 0x8D:    /* STA absolute */
  985.             ABSOL;
  986.             SETptr(A);
  987.             break;
  988.  
  989.         case 0x8E:    /* STX absolute */
  990.             ABSOL;
  991.             SETptr(X);
  992.             break;
  993.  
  994.         case 0x8F:
  995.             break;
  996.  
  997.         case 0x90:    /* BCC */
  998.             if (C) {
  999.                 PCINC;
  1000.             } else {
  1001.                 BRANCH();
  1002.             }
  1003.             break;
  1004.  
  1005.         case 0x91:    /* STA (indirect), Y */
  1006.             INDY;
  1007.             SETptr(A);
  1008.             break;
  1009.  
  1010.         case 0x92:
  1011.             break;
  1012.  
  1013.         case 0x93:
  1014.             break;
  1015.  
  1016.         case 0x94:    /* STY zero page, X */
  1017.             sZEROX(Y);
  1018.             break;
  1019.  
  1020.         case 0x95:    /* STA zero page, X */
  1021.             sZEROX(A);
  1022.             break;
  1023.  
  1024.         case 0x96:    /* STX zero page, Y */
  1025.             sZEROY(X);
  1026.             break;
  1027.  
  1028.         case 0x97:
  1029.             break;
  1030.  
  1031.         case 0x98:    /* TYA */
  1032.             A = Y;
  1033.             SIGN(A);
  1034.             ZERO(A);
  1035.             break;
  1036.  
  1037.         case 0x99:    /* STA absolute, Y */
  1038.             ABSY;
  1039.             SETptr(A);
  1040.             break;
  1041.  
  1042.         case 0x9A:    /* TXS */
  1043.             Sp = X;
  1044.             break;
  1045.  
  1046.         case 0x9B:
  1047.             break;
  1048.  
  1049.         case 0x9C:    /* STZ absolute        65C02 */
  1050.             break;
  1051.  
  1052.         case 0x9D:    /* STA absolute, X */
  1053.             ABSX;
  1054.             SETptr(A);
  1055.             break;
  1056.  
  1057.         case 0x9E:    /* STZ absolute, X    65C02 */
  1058.             break;
  1059.  
  1060.         case 0x9F:
  1061.             break;
  1062.  
  1063.         case 0xA0:    /* LDY immediate */
  1064.             Y = REFimm;
  1065.             SIGN(Y);
  1066.             ZERO(Y);
  1067.             break;
  1068.  
  1069.         case 0xA1:    /* LDA (indirect, X) */
  1070.             INDX;
  1071.             A = REFptr;
  1072.             SIGN(A);
  1073.             ZERO(A);
  1074.             break;
  1075.  
  1076.         case 0xA2:    /* LDX immediate */
  1077.             X = REFimm;
  1078.             SIGN(X);
  1079.             ZERO(X);
  1080.             break;
  1081.  
  1082.         case 0xA3:
  1083.             break;
  1084.  
  1085.         case 0xA4:     /* LDY zero page */
  1086.             Y = rZEROP;
  1087.             SIGN(Y);
  1088.             ZERO(Y);
  1089.             break;
  1090.  
  1091.         case 0xA5:    /* LDA zero page */
  1092.             A = rZEROP;
  1093.             SIGN(A);
  1094.             ZERO(A);
  1095.             break;
  1096.  
  1097.         case 0xA6:    /* LDX zero page */
  1098.             X = rZEROP;
  1099.             SIGN(X);
  1100.             ZERO(X);
  1101.             break;
  1102.  
  1103.         case 0xA7:
  1104.             break;
  1105.  
  1106.         case 0xA8:    /* TAY */
  1107.             Y = A;
  1108.             SIGN(Y);
  1109.             ZERO(Y);
  1110.             break;
  1111.  
  1112.         case 0xA9:    /* LDA immediate */
  1113.             A = REFimm;
  1114.             SIGN(A);
  1115.             ZERO(A);
  1116.             break;
  1117.  
  1118.         case 0xAA:    /* TAX */
  1119.             X = A;
  1120.             SIGN(X);
  1121.             ZERO(X);
  1122.             break;
  1123.  
  1124.         case 0xAB:
  1125.             break;
  1126.  
  1127.         case 0xAC:    /* LDY absolute */
  1128.             ABSOL;
  1129.             Y = REFptr;
  1130.             SIGN(Y);
  1131.             ZERO(Y);
  1132.             break;
  1133.  
  1134.         case 0xAD:    /* LDA absolute */
  1135.             ABSOL;
  1136.             A = REFptr;
  1137.             SIGN(A);
  1138.             ZERO(A);
  1139.             break;
  1140.  
  1141.         case 0xAE:    /* LDX absolute */
  1142.             ABSOL;
  1143.             X = REFptr;
  1144.             SIGN(X);
  1145.             ZERO(X);
  1146.             break;
  1147.  
  1148.         case 0xAF:
  1149.             break;
  1150.  
  1151.         case 0xB0:    /* BCS */
  1152.             if (C) {
  1153.                 BRANCH();
  1154.             } else {
  1155.                 PCINC;
  1156.             }
  1157.             break;
  1158.  
  1159.         case 0xB1:    /* LDA (indirect), Y */
  1160.             INDY;
  1161.             A = REFptr;
  1162.             SIGN(A);
  1163.             ZERO(A);
  1164.             break;
  1165.  
  1166.         case 0xB2:    /* LDA (indz)        65C02 */
  1167.             break;
  1168.  
  1169.         case 0xB3:
  1170.             break;
  1171.  
  1172.         case 0xB4:    /* LDY zero page, X */
  1173.             Y = rZEROX;
  1174.             SIGN(Y);
  1175.             ZERO(Y);
  1176.             break;
  1177.  
  1178.         case 0xB5:    /* LDA zero page, X */
  1179.             A = rZEROX;
  1180.             SIGN(A);
  1181.             ZERO(A);
  1182.             break;
  1183.  
  1184.         case 0xB6:    /* LDX zero page, Y */
  1185.             X = rZEROY;
  1186.             SIGN(X);
  1187.             ZERO(X);
  1188.             break;
  1189.  
  1190.         case 0xB7:
  1191.             break;
  1192.  
  1193.         case 0xB8:    /* CLV */
  1194.             V = 0;
  1195.             break;
  1196.  
  1197.         case 0xB9:    /* LDA absolute, Y */
  1198.             ABSY;
  1199.             A = REFptr;
  1200.             SIGN(A);
  1201.             ZERO(A);
  1202.             break;
  1203.  
  1204.         case 0xBA:    /* TSX */
  1205.             X = Sp;
  1206.             SIGN(X);
  1207.             ZERO(X);
  1208.             break;
  1209.  
  1210.         case 0xBB:
  1211.             break;
  1212.  
  1213.         case 0xBC:    /* LDY absolute, X */
  1214.             ABSX;
  1215.             Y = REFptr;
  1216.             SIGN(Y);
  1217.             ZERO(Y);
  1218.             break;
  1219.  
  1220.         case 0xBD:    /* LDA absolute, X */
  1221.             ABSX;
  1222.             A = REFptr;
  1223.             SIGN(A);
  1224.             ZERO(A);
  1225.             break;
  1226.  
  1227.         case 0xBE:    /* LDX absolute, Y */
  1228.             ABSY;
  1229.             X = REFptr;
  1230.             SIGN(X);
  1231.             ZERO(X);
  1232.             break;
  1233.  
  1234.         case 0xBF:
  1235.             break;
  1236.  
  1237.         case 0xC0:    /* CPY immediate */
  1238.             tmp = REFimm;
  1239.             C = (Y >= tmp);
  1240.             tmp = (Y - tmp) & 0xFF;
  1241.             SIGN(tmp);
  1242.             ZERO(tmp);
  1243.             break;
  1244.  
  1245.         case 0xC1:    /* CMP (indirect, X) */
  1246.             INDX;
  1247.             tmp = REFptr;
  1248.             C = (A >= tmp);
  1249.             tmp = (A - tmp) & 0xFF;
  1250.             SIGN(tmp);
  1251.             ZERO(tmp);
  1252.             break;
  1253.  
  1254.         case 0xC2:
  1255.             break;
  1256.  
  1257.         case 0xC3:
  1258.             break;
  1259.  
  1260.         case 0xC4:    /* CPY zero page */
  1261.             tmp = rZEROP;
  1262.             C = (Y >= tmp);
  1263.             tmp = (Y - tmp) & 0xFF;
  1264.             SIGN(tmp);
  1265.             ZERO(tmp);
  1266.             break;
  1267.  
  1268.         case 0xC5:    /* CMP zero page */
  1269.             tmp = rZEROP;
  1270.             C = (A >= tmp);
  1271.             tmp = (A - tmp) & 0xFF;
  1272.             SIGN(tmp);
  1273.             ZERO(tmp);
  1274.             break;
  1275.  
  1276.         case 0xC6:    /* DEC zero page */
  1277.             ZEROP;
  1278.             stmp = REFzero - 1;
  1279.             SETzero(stmp);
  1280.             SIGN(stmp);
  1281.             ZERO(stmp);
  1282.             break;
  1283.  
  1284.         case 0xC7:
  1285.             break;
  1286.  
  1287.         case 0xC8:    /* INY */
  1288.             Y++;
  1289.             SIGN(Y);
  1290.             ZERO(Y);
  1291.             break;
  1292.  
  1293.         case 0xC9:    /* CMP immediate */
  1294.             tmp = REFimm;
  1295.             C = (A >= tmp);
  1296.             tmp = (A - tmp) & 0xFF;
  1297.             SIGN(tmp);
  1298.             ZERO(tmp);
  1299.             break;
  1300.  
  1301.         case 0xCA:    /* DEX */
  1302.             X--;
  1303.             SIGN(X);
  1304.             ZERO(X);
  1305.             break;
  1306.  
  1307.         case 0xCB:
  1308.             break;
  1309.  
  1310.         case 0xCC:    /* CPY absolute */
  1311.             ABSOL;
  1312.             tmp = REFptr;
  1313.             C = (Y >= tmp);
  1314.             tmp = (Y - tmp) & 0xFF;
  1315.             SIGN(tmp);
  1316.             ZERO(tmp);
  1317.             break;
  1318.  
  1319.         case 0xCD:    /* CMP absolute */
  1320.             ABSOL;
  1321.             tmp = REFptr;
  1322.             C = (A >= tmp);
  1323.             tmp = (A - tmp) & 0xFF;
  1324.             SIGN(tmp);
  1325.             ZERO(tmp);
  1326.             break;
  1327.  
  1328.         case 0xCE:    /* DEC absolute */
  1329.             ABSOL;
  1330.             stmp = REFptr - 1;
  1331.             SETptr(stmp);
  1332.             SIGN(stmp);
  1333.             ZERO(stmp);
  1334.             break;
  1335.  
  1336.         case 0xCF:
  1337.             break;
  1338.  
  1339.         case 0xD0:    /* BNE */
  1340.             if (NZ) {
  1341.                 BRANCH();
  1342.             } else {
  1343.                 PCINC;
  1344.             }
  1345.             break;
  1346.  
  1347.         case 0xD1:    /* CMP (indirect), Y */
  1348.             INDY;
  1349.             tmp = REFptr;
  1350.             C = (A >= tmp);
  1351.             tmp = (A - tmp) & 0xFF;
  1352.             SIGN(tmp);
  1353.             ZERO(tmp);
  1354.             break;
  1355.  
  1356.         case 0xD2:    /* CMP (indz)        65C02 */
  1357.             break;
  1358.  
  1359.         case 0xD3:
  1360.             break;
  1361.  
  1362.         case 0xD4:
  1363.             break;
  1364.  
  1365.         case 0xD5:    /* CMP zero page, X */
  1366.             tmp = rZEROX;
  1367.             C = (A >= tmp);
  1368.             tmp = (A - tmp) & 0xFF;
  1369.             SIGN(tmp);
  1370.             ZERO(tmp);
  1371.             break;
  1372.  
  1373.         case 0xD6:    /* DEC zero page, X */
  1374.             ZEROX;
  1375.             stmp = REFzero - 1;
  1376.             SETzero(stmp);
  1377.             SIGN(stmp);
  1378.             ZERO(stmp);
  1379.             break;
  1380.  
  1381.         case 0xD7:
  1382.             break;
  1383.  
  1384.         case 0xD8:    /* CLD */
  1385.             D = 0;
  1386.             break;
  1387.  
  1388.         case 0xD9:    /* CMP absolute, Y */
  1389.             ABSY;
  1390.             tmp = REFptr;
  1391.             C = (A >= tmp);
  1392.             tmp = (A - tmp) & 0xFF;
  1393.             SIGN(tmp);
  1394.             ZERO(tmp);
  1395.             break;
  1396.  
  1397.         case 0xDA:    /* PHX        65C02 */
  1398.             break;
  1399.  
  1400.         case 0xDB:
  1401.             break;
  1402.  
  1403.         case 0xDC:
  1404.             break;
  1405.  
  1406.         case 0xDD:    /* CMP absolute, X */
  1407.             ABSX;
  1408.             tmp = REFptr;
  1409.             C = (A >= tmp);
  1410.             tmp = (A - tmp) & 0xFF;
  1411.             SIGN(tmp);
  1412.             ZERO(tmp);
  1413.             break;
  1414.  
  1415.         case 0xDE:    /* DEC absolute, X */
  1416.             ABSX;
  1417.             stmp = REFptr - 1;
  1418.             SETptr(stmp);
  1419.             SIGN(stmp);
  1420.             ZERO(stmp);
  1421.             break;
  1422.  
  1423.         case 0xDF:
  1424.             break;
  1425.  
  1426.         case 0xE0:    /* CPX immediate */
  1427.             tmp = REFimm;
  1428.             C = (X >= tmp);
  1429.             tmp = (X - tmp) & 0xFF;
  1430.             SIGN(tmp);
  1431.             ZERO(tmp);
  1432.             break;
  1433.  
  1434.         case 0xE1:    /* SBC (indirect, X) */
  1435.             INDX;
  1436.             val = REFptr;
  1437.             tmp = A & 0x80;
  1438.             stmp = val & 0x80;
  1439.             if (D) {
  1440.                 assert(FALSE);
  1441.             } else {
  1442.                 foo = A - (val + !C);
  1443.                 C = (foo >= 0);
  1444.                 A = foo & 0xFF;
  1445.             }
  1446.             ZERO(A);
  1447.             SIGN(A);
  1448.             V = (tmp != stmp) && (tmp != N);
  1449.             break;
  1450.  
  1451.         case 0xE2:
  1452.             break;
  1453.  
  1454.         case 0xE3:
  1455.             break;
  1456.  
  1457.         case 0xE4:    /* CPX zero page */
  1458.             tmp = rZEROP;
  1459.             C = (X >= tmp);
  1460.             tmp = (X - tmp) & 0xFF;
  1461.             SIGN(tmp);
  1462.             ZERO(tmp);
  1463.             break;
  1464.  
  1465.         case 0xE5:    /* SBC zero page */
  1466.             val = rZEROP;
  1467.             tmp = A & 0x80;
  1468.             stmp = val & 0x80;
  1469.             if (D) {
  1470.                 assert(FALSE);
  1471.             } else {
  1472.                 foo = A - (val + !C);
  1473.                 C = (foo >= 0);
  1474.                 A = foo & 0xFF;
  1475.             }
  1476.             ZERO(A);
  1477.             SIGN(A);
  1478.             V = (tmp != stmp) && (tmp != N);
  1479.             break;
  1480.  
  1481.         case 0xE6:    /* INC zero page */
  1482.             ZEROP;
  1483.             stmp = REFzero + 1;
  1484.             SIGN(stmp);
  1485.             ZERO(stmp);
  1486.             SETzero(stmp);
  1487.             break;
  1488.  
  1489.         case 0xE7:
  1490.             break;
  1491.  
  1492.         case 0xE8:    /* INX */
  1493.             X++;
  1494.             SIGN(X);
  1495.             ZERO(X);
  1496.             break;
  1497.  
  1498.         case 0xE9:    /* SBC immediate */
  1499.             val = REFimm;
  1500.             tmp = A & 0x80;
  1501.             stmp = val & 0x80;
  1502.             if (D) {
  1503.                 assert(FALSE);
  1504.             } else {
  1505.                 foo = A - (val + !C);
  1506.                 C = (foo >= 0);
  1507.                 A = foo & 0xFF;
  1508.             }
  1509.             ZERO(A);
  1510.             SIGN(A);
  1511.             V = (tmp != stmp) && (tmp != N);
  1512.             break;
  1513.  
  1514.         case 0xEA:    /* NOP */
  1515.             break;
  1516.  
  1517.         case 0xEB:
  1518.             break;
  1519.  
  1520.         case 0xEC:    /* CPX absolute */
  1521.             ABSOL;
  1522.             tmp = REFptr;
  1523.             C = (X >= tmp);
  1524.             tmp = (X - tmp) & 0xFF;
  1525.             SIGN(tmp);
  1526.             ZERO(tmp);
  1527.             break;
  1528.  
  1529.         case 0xED:    /* SBC absolute */
  1530.             ABSOL;
  1531.             val = REFptr;
  1532.             tmp = A & 0x80;
  1533.             stmp = val & 0x80;
  1534.             if (D) {
  1535.                 assert(FALSE);
  1536.             } else {
  1537.                 foo = A - (val + !C);
  1538.                 C = (foo >= 0);
  1539.                 A = foo & 0xFF;
  1540.             }
  1541.             ZERO(A);
  1542.             SIGN(A);
  1543.             V = (tmp != stmp) && (tmp != N);
  1544.             break;
  1545.  
  1546.         case 0xEE:    /* INC absolute */
  1547.             ABSOL;
  1548.             stmp = REFptr + 1;
  1549.             SETptr(stmp);
  1550.             SIGN(stmp);
  1551.             ZERO(stmp);
  1552.             break;
  1553.  
  1554.         case 0xEF:
  1555.             break;
  1556.  
  1557.         case 0xF0:    /* BEQ */
  1558.             if (NZ) {
  1559.                 PCINC;
  1560.             } else {
  1561.                 BRANCH();
  1562.             }
  1563.             break;
  1564.  
  1565.         case 0xF1:    /* SBC (indirect), Y */
  1566.             INDY;
  1567.             val = REFptr;
  1568.             tmp = A & 0x80;
  1569.             stmp = val & 0x80;
  1570.             if (D) {
  1571.                 assert(FALSE);
  1572.             } else {
  1573.                 foo = A - (val + !C);
  1574.                 C = (foo >= 0);
  1575.                 A = foo & 0xFF;
  1576.             }
  1577.             ZERO(A);
  1578.             SIGN(A);
  1579.             V = (tmp != stmp) && (tmp != N);
  1580.             break;
  1581.  
  1582.         case 0xF2:    /* SBC (indz)        65C02 */
  1583.             break;
  1584.  
  1585.         case 0xF3:
  1586.             break;
  1587.  
  1588.         case 0xF4:
  1589.             break;
  1590.  
  1591.         case 0xF5:    /* SBC zero page, X */
  1592.             val = rZEROX;
  1593.             tmp = A & 0x80;
  1594.             stmp = val & 0x80;
  1595.             if (D) {
  1596.                 assert(FALSE);
  1597.             } else {
  1598.                 foo = A - (val + !C);
  1599.                 C = (foo >= 0);
  1600.                 A = foo & 0xFF;
  1601.             }
  1602.             ZERO(A);
  1603.             SIGN(A);
  1604.             V = (tmp != stmp) && (tmp != N);
  1605.             break;
  1606.  
  1607.         case 0xF6:    /* INC zero page, X */
  1608.             ZEROX;
  1609.             stmp = REFzero + 1;
  1610.             SETzero(stmp);
  1611.             SIGN(stmp);
  1612.             ZERO(stmp);
  1613.             break;
  1614.  
  1615.         case 0xF7:
  1616.             break;
  1617.  
  1618.         case 0xF8:    /* SED */
  1619.             D = 1;
  1620.             break;
  1621.  
  1622.         case 0xF9:    /* SBC absolute, Y */
  1623.             ABSY;
  1624.             val = REFptr;
  1625.             tmp = A & 0x80;
  1626.             stmp = val & 0x80;
  1627.             if (D) {
  1628.                 assert(FALSE);
  1629.             } else {
  1630.                 foo = A - (val + !C);
  1631.                 C = (foo >= 0);
  1632.                 A = foo & 0xFF;
  1633.             }
  1634.             ZERO(A);
  1635.             SIGN(A);
  1636.             V = (tmp != stmp) && (tmp != N);
  1637.             break;
  1638.  
  1639.         case 0xFA:    /* PLX        65C02 */
  1640.             break;
  1641.  
  1642.         case 0xFB:
  1643.             break;
  1644.  
  1645.         case 0xFC:
  1646.             break;
  1647.  
  1648.         case 0xFD:    /* SBC absolute, X */
  1649.             ABSX;
  1650.             val = REFptr;
  1651.             tmp = A & 0x80;
  1652.             stmp = val & 0x80;
  1653.             if (D) {
  1654.                 assert(FALSE);
  1655.             } else {
  1656.                 foo = A - (val + !C);
  1657.                 C = (foo >= 0);
  1658.                 A = foo & 0xFF;
  1659.             }
  1660.             ZERO(A);
  1661.             SIGN(A);
  1662.             V = (tmp != stmp) && (tmp != N);
  1663.             break;
  1664.  
  1665.         case 0xFE:    /* INC absolute, X */
  1666.             ABSX;
  1667.             stmp = REFptr + 1;
  1668.             SETptr(stmp);
  1669.             SIGN(stmp);
  1670.             ZERO(stmp);
  1671.             break;
  1672.  
  1673.         case 0xFF:
  1674.             break;
  1675.         }
  1676.     } while (running);
  1677.  
  1678.     if (show_flags)
  1679.         flags(logging_fp);
  1680.     } while (tracing);
  1681. }
  1682.  
  1683.  
  1684.